﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using System.Data.SqlClient;
using vudu.ClasesDominio;
using vudu.Logica.Clases;
using System.IO;

namespace vudu.Datos.SqlServer
{
    public class SqlServerArchivoPdf
    {

        Conexion _miConexion; 
        SqlCommand _command; 
        SqlDataReader _reader;

        public SqlServerArchivoPdf()
        {
            _miConexion = new Conexion();
            _command = new SqlCommand();
            _reader = null;
        }
        //Nuevo
        public List<Universidad> ConsultarUniversidadesProfesor(int idProfesor)
        {
            try
            {

                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarUniversidadesProfesorPdf]";
                _command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idProfesor", idProfesor);
                _command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                //se carga la informacion consultada en un objeto datatable
                List<Universidad> listaUni = new List<Universidad>();
                _reader = _command.ExecuteReader();
                while (_reader.Read())
                {
                    Universidad uni = new Universidad();
                    uni.IdUniv = _reader.GetInt32(0);
                    uni.Nombre = _reader.GetString(1);
                    listaUni.Add(uni);

                }


                return listaUni;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }
        }

        public List<Escuela> ConsultarEscuelasProfesor(string nombreUniv, int idProfesor)
        {
            try
            {

                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarEscuelasProfesorPdf]";
                _command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idProfesor", idProfesor);
                _command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                _command.Parameters.AddWithValue("@nombreUniversidad", nombreUniv);
                _command.Parameters["@nombreUniversidad"].Direction = ParameterDirection.Input;
                //se ejecuta el comando
                //se carga la informacion consultada en un objeto datatable
                List<Escuela> listaEsc = new List<Escuela>();
                _reader = _command.ExecuteReader();
                while (_reader.Read())
                {
                    Escuela esc = new Escuela();
                    esc.IdEscuela = _reader.GetInt32(0);
                    esc.NombreEscuela = _reader.GetString(1);
                    listaEsc.Add(esc);

                }


                return listaEsc;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }
        }


        public List<Materia> ConsultarMateriasProfesorPdf(int idProfesor, string nombreUniv, string nombreEscuela)
        {
            try
            {

                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarMateriasProfesorArchivoPdf]";
                _command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idProfesor", idProfesor);
                _command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                _command.Parameters.AddWithValue("@nombreEscuela", nombreEscuela);
                _command.Parameters["@nombreEscuela"].Direction = ParameterDirection.Input;
                _command.Parameters.AddWithValue("@nombreUniversidad", nombreUniv);
                _command.Parameters["@nombreUniversidad"].Direction = ParameterDirection.Input;
                //se ejecuta el comando
                List<Materia> listaMateria = new List<Materia>();
                _reader = _command.ExecuteReader();
                while (_reader.Read())
                {
                    Materia mat = new Materia();
                    mat.Nombre = _reader.GetString(0);
                    listaMateria.Add(mat);

                }


                return listaMateria;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }
        }

        public List<SeccionMateria> ConsultarSeccionesProfesorPdf(int idProfesor, string nombreUniv, string nombreEscuela, string nombreMateria)
        {
            try
            {

                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarSeccionesProfesorArchivoPdf]";
                _command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idProfesor", idProfesor);
                _command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                _command.Parameters.AddWithValue("@nombreEscuela", nombreEscuela);
                _command.Parameters["@nombreEscuela"].Direction = ParameterDirection.Input;
                _command.Parameters.AddWithValue("@nombreUniversidad", nombreUniv);
                _command.Parameters["@nombreUniversidad"].Direction = ParameterDirection.Input;
                _command.Parameters.AddWithValue("@nombreMateria", nombreMateria);
                _command.Parameters["@nombreMateria"].Direction = ParameterDirection.Input;
                //se ejecuta el comando
                List<SeccionMateria> listaSeccion = new List<SeccionMateria>();
                _reader = _command.ExecuteReader();
                while (_reader.Read())
                {
                    SeccionMateria seccion = new SeccionMateria();
                    seccion.Codigo = _reader.GetInt32(0);
                    seccion.IdSeccionMateria = _reader.GetInt32(1);
                    seccion.EspacioUtlizado = _reader.GetInt32(2);
                    seccion.EspacioMaxCarga = _reader.GetInt32(3);
                    listaSeccion.Add(seccion);
                }
                return listaSeccion;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }
        }

        public DataTable consultarArchivoProfesor(int idProfesor, int NumeroSeccion)
        {
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            SqlDataReader reader = null;

            try
            {
               
                //se abre una conexion a base de datos
                miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[ConsultarArchivoPdf]";
                command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@idProfesor", idProfesor);
                command.Parameters.AddWithValue("@NumeroSeccion",NumeroSeccion);
                command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                command.Parameters["@NumeroSeccion"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                //se carga la informacion consultada en un objeto datatable
                DataTable dtt = new DataTable();
                dtt.Load(command.ExecuteReader(), LoadOption.OverwriteChanges);

                
                
                return dtt;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (reader != null)
                    reader.Close();
                miConexion.CerrarConexionBd();
            }

        }

        public DataTable ConsultarArchivoEstudiante(int idSeccion)
        {
            try
            {
                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarArchivoPdfEstudiante]";
                _command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idSeccion", idSeccion);
                _command.Parameters["@idSeccion"].Direction = ParameterDirection.Input;
                //se ejecuta el comando
                //se carga la informacion consultada en un objeto de tipo DataTable
                DataTable dtt = new DataTable();
                dtt.Load(_command.ExecuteReader(), LoadOption.OverwriteChanges);
                              
                return dtt;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }

        }

        public List<SeccionMateria> ConsultarSeccionesProfesorArchivoPdf(Profesor profesor)
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            SqlDataReader reader = null;
            try
            {
                //se abre una conexion a base de datos
                miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[ConsultarMateriasProfesorArchivoPdf]";
                command.CommandTimeout = 10;

                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@idProfesor", profesor.Cedula);
                command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                //se carga la informacion consultada en una lista de objeto de tipo SeccionMateria
                List<SeccionMateria> materiasProfesor = new List<SeccionMateria>();
                reader = command.ExecuteReader();
                while (reader.Read())
                {
                    SeccionMateria seccionMateria = new SeccionMateria();
                    seccionMateria.Materia.Nombre = reader.GetString(0);
                    materiasProfesor.Add(seccionMateria);

                }
                return materiasProfesor;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (reader != null)
                    reader.Close();
                miConexion.CerrarConexionBd();
            }
        }

        public List<OperacionesPdf> ConsultarCategoriaProfesorArchivoPdf(Profesor profesor, int idSeccion)
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            SqlDataReader reader = null;
            try
            {
                //se abre una conexion a base de datos
                miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[ConsultarCategoriaProfesorArchivoPdf]";
                command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@idSeccion", idSeccion);
                command.Parameters.AddWithValue("@idProfesor", profesor.Cedula);
                command.Parameters["@idSeccion"].Direction = ParameterDirection.Input;
                command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                //se ejecuta el comando
                //se carga la informacion consultada en una lista de objeto de tipo OperacionesPdf
                List<OperacionesPdf> categoriaProfesor = new List<OperacionesPdf>();
                reader = command.ExecuteReader();
                while (reader.Read())
                {
                    OperacionesPdf miCategoria = new OperacionesPdf();
                    //Ojo comentado
                    //miCategoria.categoria = reader.GetString(0);
                    //categoriaProfesor.Add(miCategoria);

                }
                return categoriaProfesor;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (reader != null)
                    reader.Close();
                miConexion.CerrarConexionBd();
            }
        }

        public List<OperacionesPdf> ConsultarNombreArchivoPdf(Profesor profesor, int idSeccion, String nombreCategoria)
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            SqlDataReader reader = null;
            try
            {
                //se abre una conexion a base de datos
                miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[ConsultarNombreArchivoPdf]";
                command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@idSeccion", idSeccion);
                command.Parameters.AddWithValue("@idProfesor", profesor.Cedula);
                command.Parameters.AddWithValue("@nombreCategoria", nombreCategoria);
                command.Parameters["@idSeccion"].Direction = ParameterDirection.Input;
                command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                command.Parameters["@nombreCategoria"].Direction = ParameterDirection.Input;
                //se ejecuta el comando
                //se carga la informacion consultada en una lista de objeto de tipo OperacionesPdf
                List<OperacionesPdf> categoriaProfesor = new List<OperacionesPdf>();
                reader = command.ExecuteReader();
                while (reader.Read())
                {
                    OperacionesPdf miCategoria = new OperacionesPdf();
                    miCategoria.idArchivo = reader.GetInt32(0);
                    miCategoria.nombreArchivo = reader.GetString(1);
                    miCategoria.rutaArchivoPdf = new FileInfo(reader.GetString(2));
                 //   miCategoria.categoria = reader.GetString(3);
                    categoriaProfesor.Add(miCategoria);

                }
                return categoriaProfesor;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (reader != null)
                    reader.Close();
                miConexion.CerrarConexionBd();
            }
        }

        public List<SeccionMateria> ConsultarSeccionesEstudianteArchivoPdf(Estudiante estudiante)
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            SqlDataReader reader = null;
            try
            {
                //se abre una conexion a base de datos
                miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[ConsultarDatosMateriaEstudianteArchivoPdf]";
                command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@idEstudiante", estudiante.IdEst);
                command.Parameters["@idEstudiante"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                //se carga la informacion consultada en una lista de objeto de tipo SeccionMateria
                List<SeccionMateria> materiasProfesor = new List<SeccionMateria>();
                reader = command.ExecuteReader();
                while (reader.Read())
                {
                    SeccionMateria seccionMateria = new SeccionMateria();
                   
                    seccionMateria.Codigo = reader.GetInt32(0);
                    seccionMateria.Materia.Nombre = reader.GetString(1);
                    seccionMateria.IdSeccionMateria = reader.GetInt32(2);
                    materiasProfesor.Add(seccionMateria);

                }
                return materiasProfesor;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (reader != null)
                    reader.Close();
                miConexion.CerrarConexionBd();
            }
        }

        public List<SeccionMateria> ConsultarDatosSeccionProfesorArchivoPdf(Profesor profesor, SeccionMateria seccion)
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            SqlDataReader reader = null;
            try
            {
                //se abre una conexion a base de datos
                miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[ConsultarDatosMateriasProfesorArchivoPdf]";
                command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@idProfesor", profesor.Cedula);
                command.Parameters.AddWithValue("@nombreMateria", seccion.Materia.Nombre);
                command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                command.Parameters["@nombreMateria"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                //se carga la informacion consultada en una lista de objeto de tipo SeccionMateria
                List<SeccionMateria> materiasProfesor = new List<SeccionMateria>();
                reader = command.ExecuteReader();
                while (reader.Read())
                {
                    SeccionMateria seccionMateria = new SeccionMateria();
                    seccionMateria.Codigo = reader.GetInt32(0);
                    seccionMateria.IdSeccionMateria = reader.GetInt32(1);

                    materiasProfesor.Add(seccionMateria);

                }
                return materiasProfesor;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (reader != null)
                    reader.Close();
                miConexion.CerrarConexionBd();
            }
        }

        public bool InsertarArchivoPdf(OperacionesPdf archivoPdf,float tamañoArchivo,int crn, int idSeccion)
        {
            Conexion miConexion = new Conexion();
            SqlCommand command = new SqlCommand();
            try
            {
                miConexion.AbrirConexionBd(); //se abre una conexion a base de datos

                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                command.Connection = miConexion.ObjetoConexion();
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.CommandText = "[dbo].[InsertarArchivoPdf]";
                command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                command.Parameters.AddWithValue("@nombre",archivoPdf.nombreArchivo);
                command.Parameters.AddWithValue("@ruta", archivoPdf.rutaArchivoPdf.ToString());
                command.Parameters.AddWithValue("@fk_categoria",archivoPdf.categoria.IdCategoria);
                command.Parameters.AddWithValue("@fk_profesor", crn);
                command.Parameters.AddWithValue("@fk_SeccionMateria",idSeccion);
                command.Parameters.AddWithValue("@espacioUtilizado", tamañoArchivo);

                command.Parameters["@nombre"].Direction = ParameterDirection.Input;
                command.Parameters["@ruta"].Direction = ParameterDirection.Input;
                command.Parameters["@fk_categoria"].Direction = ParameterDirection.Input;
                command.Parameters["@fk_profesor"].Direction = ParameterDirection.Input;
                command.Parameters["@fk_SeccionMateria"].Direction = ParameterDirection.Input;
                command.Parameters["@espacioUtilizado"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                command.ExecuteReader();
                
            }
            catch (SqlException)
            {
                miConexion.CerrarConexionBd();
                return false;
            }
            catch (Exception e)
            {
                miConexion.CerrarConexionBd();
                return false;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                miConexion.CerrarConexionBd();
            }
            return true;
        }

        public bool EliminarArchivoPdf(OperacionesPdf miArchivo, int IdSeccion)
        {
           try
            {
                _miConexion.AbrirConexionBd(); //se abre una conexion a base de datos

                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[EliminarArchivoPdf]";
                _command.CommandTimeout = 10;

                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idArchivo",miArchivo.idArchivo);
                _command.Parameters.AddWithValue("@tamañoActual", miArchivo.Peso);
                _command.Parameters.AddWithValue("@idSeccion", IdSeccion);
                _command.Parameters["@idArchivo"].Direction = ParameterDirection.Input;
                _command.Parameters["@tamañoActual"].Direction = ParameterDirection.Input;
                _command.Parameters["@idSeccion"].Direction = ParameterDirection.Input;
                          
                //se ejecuta el comando
                _command.ExecuteReader();
                return true;
               
            }
            catch (SqlException)
            {
                return false;
            }
            catch (Exception e)
            {
                return false;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                _miConexion.CerrarConexionBd();
            }
        }

        public List<Categoria> ConsultarCategorias(int idSeccion, int idProfesor)
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            try
            {
                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarCategoriaProfesorArchivoPdf]";
                _command.CommandTimeout = 10;

                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idSeccion", idSeccion);
                _command.Parameters.AddWithValue("@idProfesor", idProfesor);
                _command.Parameters["@idSeccion"].Direction = ParameterDirection.Input;
                _command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;

                //se ejecuta el comando
                //se carga la informacion consultada en una lista de objeto de tipo OperacionesPdf

                List<Categoria> misCategoria = new List<Categoria>();
                _reader = _command.ExecuteReader();
                while (_reader.Read())
                {
                    Categoria miCategoria = new Categoria();
                    miCategoria.Nombre = _reader.GetString(0);
                    miCategoria.IdCategoria = _reader.GetInt32(1);
                    misCategoria.Add(miCategoria);

                }
                return misCategoria;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }
        }

        public List<Categoria> ConsultarAllCategoriasPdf()
        {
            //se instancia un objeto de tipo conexion y sqlCommand
            //estos se utilizan para acceder a base de datos y ejecutar el stored procedure en sql server
            try
            {
                //se abre una conexion a base de datos
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarCategorias]";
                _command.CommandTimeout = 10;
                List<Categoria> misCategoria = new List<Categoria>();
                _reader = _command.ExecuteReader();
                while (_reader.Read())
                {
                    Categoria miCategoria = new Categoria();
                    miCategoria.IdCategoria = _reader.GetInt32(0);
                    miCategoria.Nombre = _reader.GetString(1);
                    misCategoria.Add(miCategoria);

                }
               
                return misCategoria;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e.StackTrace);
                System.Console.ReadLine();
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }
        }
        
        
        public List<OperacionesPdf> ConsultarArchivosPdf( int NumeroSeccion, int idProfesor, string categoria)
        {
            try
            {
                _miConexion.AbrirConexionBd();
                // se completa el objeto comando, con la informacion de la conexion , variables, y nombre del stored procedure.
                _command.Connection = _miConexion.ObjetoConexion();
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.CommandText = "[dbo].[ConsultarArchivoPdfCategoria]";
                _command.CommandTimeout = 10;
                //variables del stored procedure de sql server.
                _command.Parameters.AddWithValue("@idProfesor", idProfesor);
                _command.Parameters.AddWithValue("@NumeroSeccion",NumeroSeccion);
                _command.Parameters.AddWithValue("@categoria", categoria);
                _command.Parameters["@idProfesor"].Direction = ParameterDirection.Input;
                _command.Parameters["@NumeroSeccion"].Direction = ParameterDirection.Input;
                 _command.Parameters["@categoria"].Direction = ParameterDirection.Input;

                 //se ejecuta el comando    miCategoria.rutaArchivoPdf = new FileInfo(reader.GetString(2));

                 List<OperacionesPdf> misArchivos = new List<OperacionesPdf>();
                 _reader = _command.ExecuteReader();
                 while (_reader.Read())
                 {
                     OperacionesPdf miArchivo = new OperacionesPdf();
                     miArchivo.nombreArchivo = _reader.GetString(0);
                     miArchivo.rutaArchivoPdf = new FileInfo(_reader.GetString(1));
                     Categoria cat = new Categoria();
                     cat.Nombre = _reader.GetString(2);
                     miArchivo.categoria = cat;
                     miArchivo.Peso = _reader.GetInt32(3);
                     miArchivo.idArchivo = _reader.GetInt32(4);
                     misArchivos.Add(miArchivo);

                 }
                 return misArchivos;
            }
            catch (SqlException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
            //se cierra la conexion independientemente de que se haya detectado o no una excepcion.
            finally
            {
                if (_reader != null)
                    _reader.Close();
                _miConexion.CerrarConexionBd();
            }

        }

 
    }
}